Go语言有什么不同？

#Go语言有什么不同？| 来源: 网络整理| 查看: 265

Go让我体验到了从未有过的开发效率。 --Go作者之一：罗布·派克(Rob Pike)

开发效率，是的，我们新入这门开发语言最直接的感受就是语法简洁高效，甚至有人用“逆天”两个字来形容它的这一特色。本文就抛开其他，看看Go语言倒底有什么不同，它如何帮我们提高开发效率。

查看原文

不需加分号格式化工具隐式初始化自增&自减空标识符短变量声明多重赋值 switch不需要break 不需要Public、Private 减少类型转换潜规则类型不同，不能运算基础类型不同，不能转换常量 Slice（切片） defer 多返回值没有类接口用法优点 Goroutines 附录关于分号不需加分号

Go语言不需要在语句或者声明的末尾加分号，编译器会主动加分号。少写一个字是一个字 :)。如果你喜欢个性化的代码风格，需要参与一下附录--关于分号。

格式化工具

Go自带了格式化工具

gofmt Go语言在代码格式化上态度很强硬。gofmt会按标准格式化代码，没有任何参数，你只能按标准走。你不用操心什么样的代码风格更好，执行标准就行，简单了很多，少了不必要的撒逼。 goimports 根据需要，自动添加或删除import声明。这个省了不少事。这个工具没包含在标准包中，可以go get golang.org/x/tools/goimports

gofmt和goimports在一些开发工具中(vscode,idea...)会自动执行，你再也不需要苦逼的去手动执行了。

隐式初始化

如果声明变量时，没有显式初始化，则被隐式初始化为变量类型的0值。

不同类型的零值数值，0 字符串，"" 布尔，false 接口或引用类型, nil

不需要操心undefined了

自增&自减

和C系其他语言一样，Go也有++和--，但是Go语言中自增自减是语句不是表达式,并且++和--只能放在变量后。所以注意以下用法：

// 合法 i++ i-- // 非法，自增自减不是表达式 j = i++ j = i-- // 非法，++和--只能放在变量后面 ++i --i

我记得曾有同学分不清C语言中的++i和i++，另外，像j = ++i这种用法更是扰乱视听。现在好了，解放了，老老实实用好i++和i--就够了

空标识符

Go语言不允许使用无用的变量，因此就有了空标识符，即_（下划线）。空标识符多用在接收函数多返回值时，对不需要的返回值作占位用。

短变量声明

在函数内可以用a:=3的方式声明变量，编译器会自动推算出变量a的数据类型。简洁，但只能用在函数内。

用过Pascal的同学可能注意到 ':=' 的用法，没错，Go语言不但继承了C的很多思想，Go的另一支继承分支就是Pascal

多重赋值

Go语言中可以这样用：

// 声明变量i和j 结果：类型都是int，i的值是0，j的值是1 i, j := 0, 1 // 给i和j重新赋值结果：i的值是2，j的值是3 i, j = 2, 3 // 重点来了，变量值的交换结果：i的值是3，j的值是2 i, j = j, i // 当然，还可以这样： a[i], a[j] = a[j], a[i] // 还记得其他语言中通过临时变量来交换数据吗？上面的用法与其他语言相比，只能用幸福来形容:) // 计算斐波纳契数据的第n个数： func gcd(x, y int) int { for y != 0 { x, y = y, x%y } return x } switch不需要break

以前在其他语言中使用switch总是很麻烦，每个case语句之后都要加break,Go不需要！

其他语言是这样 switch( foo ) { case "alpha": alpha(); break; case "beta": beta(); break; default: // something to default to break; } Go语言是这样 switch foo { case "alpha": alpha() case "beta": beta() default: // something to default to }

Go语言中，如果想要几个相邻的case执行同一段逻辑，需要自己显式的加入fallthrough语句。像这样不用break才合理嘛，毕竟fallthrough的方式很少用到。

不需要Public、Private

Go语言中，以大写字母开头的变量、函数命名作为公有变量（或函数）导出。也就是说外部的包只能访问以大写字母开头的变量（或函数）。结构体成员命名也遵循此规则。

减少类型转换潜规则类型不同，不能运算

Go语言中，即使是基础类型相同，不同的类型之间也不能进行运算：

// 定义了两个不同类型Age和Num，其基础类型都是int16 type Age int16 type Num int16 func typeTest() { var myAge Age = 3 var aNum Num = 4 // myAge与aNum类型不同，compile error: type mismatch myAge = aNum - myAge // myAge与aNum类型不同，compile error: type mismatch if myAge == aNum { fmt.Println("ok") } }

要想不同类型之间运算必须强制类型转换：

type Age int16 type Num int16 func typeTest() { var myAge Age = 3 var aNum Num = 4 // 使用Age(aNum)转换aNum myAge = Age(aNum) - myAge // 使用Age(aNum)转换aNum if myAge == Age(aNum) { fmt.Println("ok") } } 基础类型不同，不能转换 type Age int16 type Num int16 type FType float64 func typeTest() { var myAge Age = 3 var aFloat FType = 5.5 var sAge = "6" // 可以转换，但会将float截断，只保留整数 myAge = Age(aFloat) - myAge // 输出结果：2 fmt.Println(myAge) // 编译错误 myAge = sAge // 编译错误 myAge = Age(sAge) }

Go语言中基本类型的转换需要使用转换函数

上面两条类型转换相关的内容和高效有关系吗？有，变量使用中没有那么多的隐式转换，不是更直接高效吗？对于我这种记不住那么多潜规则的懒人来说确实减轻了不少心智压力:)

常量以省略方式批量初始化常量 // 下面声明了5个常量 const ( a = 1 b c d = 2 e ) fmt.Println(a, b, c, d, e) //"1 1 1 2 2" iota常量生成器在每一个const关键字出现时，iota被重置为0,每出现一个常量声明，iota自动加1 const ( a = iota // iota重置为0，a等于0 b // iota自动加1,b等于1 c // iota自动加1,c等于2 ) const ( d = iota // iota重置为0，d等于0 e // iota自动加1,e等于1 ) const f = iota // iota重置为0，f等于0 const g = iota // iota重置为0，g等于0 fmt.Println(a, b, c, d, e, f, g) //"0 1 2 0 1 0 0" 结合以上两种语法 const ( a = iota // iota重置为0，a等于0 b // iota自增,b等于1 c = "hh" // c等于“hh”,iota依然自增，等于2 d // d等于“hh”,iota依然自增，等于3 e = iota // 恢复iota, iota自增，e等于4 f // iota自增,f等于5 g // iota自增,f等于6 ) fmt.Println(a, b, c, d, e, f, g) //0 1 hh hh 4 5 6 const ( _ = 1

【本文地址】

公司简介

联系我们